home *** CD-ROM | disk | FTP | other *** search
/ Amiga Collections: Camelot / Camelot 043 (1989-06)(Swedish User Group of Amiga)(SE)(PD)[WB].zip / Camelot 043 (1989-06)(Swedish User Group of Amiga)(SE)(PD)[WB].adf / Glib / yama_com.c < prev   
C/C++ Source or Header  |  1989-03-16  |  24KB  |  895 lines
  1. /*
  2.  * GLIB - a Generic LIBrarian and editor for synths
  3.  *
  4.  * Yamaha Common Routines
  5.  */
  6.  
  7. #define OVERLAY1
  8.  
  9. #include "glib.h"
  10. #include <ctype.h>
  11.  
  12. #define DX100VSIZE 128
  13. #define DX100NSIZE 17
  14.  
  15. char *visnum(), *visonoff(), *vism3num(), *viswave(), *vismono();
  16. char *visfreq(), *visdx1a();
  17. extern int Tx81;
  18.  
  19. int *txindex = NULL;
  20. int txleng = 0;
  21.  
  22.  
  23. extern int Dopmap[];
  24.  
  25. int Tx81 = 0;    /* 1 means we're talking to the TX81Z */
  26. int Dopmap[] = { 3,1,2,0 };
  27.  
  28. int txfreq[] = {
  29. 50, 56, 62, 69, 75, 81, 87, 93,
  30.      100, 106, 112, 118, 124, 131, 137, 143,
  31. 71, 80, 88, 97, 106, 115, 123, 132,
  32.      141, 149, 158, 167, 176, 184, 193, 202,
  33. 78, 88, 98, 107, 117, 127, 137, 147,
  34.      156, 166, 176, 186, 196, 205, 215, 225,
  35. 87, 98, 108, 119, 130, 141, 151, 162,
  36.      173, 183, 194, 205, 216, 226, 237, 248,
  37. 100, 106, 112, 119, 125, 131, 137, 143,
  38.      149, 156, 162, 168, 174, 180, 187, 193,
  39. 141, 150, 159, 167, 176, 185, 194, 203,
  40.      211, 220, 229, 238, 247, 255, 264, 273,
  41. 157, 167, 177, 186, 196, 206, 216, 226,
  42.      235, 245, 255, 265, 275, 284, 294, 304,
  43. 173, 184, 195, 205, 216, 227, 238, 249,
  44.      259, 270, 281, 292, 303, 313, 324, 335,
  45. 200, 206, 212, 218, 225, 231, 237, 243,
  46.      249, 256, 262, 268, 274, 280, 287, 293,
  47. 282, 291, 300, 308, 317, 326, 335, 344,
  48.      352, 361, 370, 379, 388, 396, 405, 414,
  49. 300, 306, 312, 318, 325, 331, 337, 343,
  50.      349, 356, 362, 368, 374, 380, 387, 393,
  51. 314, 324, 334, 343, 353, 363, 373, 383,
  52.      392, 402, 412, 422, 432, 441, 451, 461,
  53. 346, 357, 368, 378, 389, 400, 411, 422,
  54.      432, 443, 454, 465, 476, 486, 497, 508,
  55. 400, 406, 412, 418, 425, 431, 437, 443,
  56.      449, 456, 462, 468, 474, 480, 487, 493,
  57. 424, 433, 441, 450, 459, 468, 476, 485,
  58.      494, 503, 511, 520, 529, 537, 546, 555,
  59. 471, 481, 491, 500, 510, 520, 530, 539,
  60.      549, 559, 569, 579, 588, 598, 608, 618,
  61. 500, 506, 512, 519, 525, 531, 537, 543,
  62.      550, 556, 562, 568, 574, 581, 587, 593,
  63. 519, 530, 540, 551, 562, 573, 584, 594,
  64.      605, 616, 627, 638, 648, 659, 670, 681,
  65. 565, 574, 582, 591, 600, 609, 617, 626,
  66.      635, 644, 652, 661, 670, 678, 687, 696,
  67. 600, 606, 612, 619, 625, 631, 637, 643,
  68.      650, 656, 662, 668, 674, 681, 687, 693,
  69. 628, 638, 647, 657, 667, 677, 687, 696,
  70.      706, 716, 726, 736, 745, 755, 765, 775,
  71. 692, 703, 713, 724, 735, 746, 757, 767,
  72.      778, 789, 800, 811, 821, 832, 843, 854,
  73. 700, 706, 712, 719, 725, 731, 737, 743,
  74.      750, 756, 762, 768, 774, 781, 787, 793,
  75. 707, 716, 724, 733, 742, 750, 759, 768,
  76.      776, 785, 794, 802, 811, 820, 828, 837,
  77. 785, 795, 804, 814, 824, 834, 844, 853,
  78.      863, 873, 883, 893, 902, 912, 922, 932,
  79. 800, 806, 812, 819, 825, 831, 837, 843,
  80.      850, 856, 862, 868, 874, 881, 887, 893,
  81. 848, 857, 865, 874, 883, 891, 900, 909,
  82.      917, 926, 935, 943, 952, 961, 969, 978,
  83. 865, 876, 886, 897, 908, 919, 930, 940,
  84.      951, 962, 973, 984, 994, 1005, 1016, 1027,
  85. 900, 906, 912, 919, 925, 931, 937, 943,
  86.      950, 956, 962, 968, 974, 981, 987, 993,
  87. 942, 952, 961, 971, 981, 991, 1001, 1010,
  88.      1020, 1030, 1040, 1050, 1059, 1069, 1079, 1089,
  89. 989, 998, 1006, 1015, 1024, 1032, 1041, 1050,
  90.      1058, 1067, 1076, 1084, 1093, 1102, 1110, 1119,
  91. 1000, 1006, 1012, 1019, 1025, 1031, 1037, 1043,
  92.      1050, 1056, 1062, 1068, 1074, 1081, 1087, 1093,
  93. 1038, 1049, 1060, 1070, 1081, 1092, 1103, 1113,
  94.      1124, 1135, 1146, 1157, 1167, 1178, 1189, 1200,
  95. 1099, 1109, 1119, 1128, 1138, 1148, 1158, 1167,
  96.      1177, 1187, 1197, 1207, 1216, 1226, 1236, 1246,
  97. 1100, 1106, 1112, 1119, 1125, 1131, 1137, 1143,
  98.      1150, 1156, 1162, 1168, 1174, 1181, 1187, 1193,
  99. 1130, 1139, 1147, 1156, 1165, 1173, 1182, 1191,
  100.      1199, 1208, 1217, 1225, 1234, 1243, 1251, 1260,
  101. 1200, 1206, 1212, 1219, 1225, 1231, 1237, 1243,
  102.      1250, 1256, 1262, 1268, 1274, 1281, 1287, 1293,
  103. 1211, 1222, 1233, 1243, 1254, 1265, 1276, 1286,
  104.      1297, 1308, 1319, 1330, 1340, 1351, 1362, 1373,
  105. 1256, 1266, 1276, 1285, 1295, 1305, 1315, 1324,
  106.      1334, 1344, 1354, 1364, 1373, 1383, 1393, 1403,
  107. 1272, 1281, 1289, 1298, 1306, 1315, 1323, 1332,
  108.      1341, 1349, 1358, 1366, 1375, 1384, 1392, 1401,
  109. 1300, 1306, 1312, 1319, 1325, 1331, 1337, 1343,
  110.      1350, 1356, 1362, 1368, 1374, 1381, 1387, 1393,
  111. 1384, 1395, 1406, 1416, 1427, 1438, 1449, 1459,
  112.      1470, 1481, 1492, 1503, 1513, 1524, 1535, 1546,
  113. 1400, 1406, 1412, 1419, 1425, 1431, 1437, 1443,
  114.      1450, 1456, 1462, 1468, 1474, 1481, 1487, 1493,
  115. 1410, 1419, 1428, 1436, 1445, 1454, 1463, 1471,
  116.      1480, 1489, 1498, 1507, 1515, 1524, 1533, 1542,
  117. 1413, 1423, 1433, 1442, 1452, 1462, 1472, 1481,
  118.      1491, 1501, 1511, 1521, 1530, 1540, 1550, 1560,
  119. 1500, 1506, 1512, 1519, 1525, 1531, 1537, 1543,
  120.      1550, 1556, 1562, 1568, 1574, 1581, 1587, 1593,
  121. 1555, 1563, 1572, 1581, 1589, 1598, 1606, 1615,
  122.      1623, 1632, 1640, 1649, 1657, 1666, 1674, 1683,
  123. 1557, 1568, 1579, 1589, 1600, 1611, 1622, 1632,
  124.      1643, 1654, 1665, 1676, 1686, 1697, 1708, 1719,
  125. 1570, 1580, 1590, 1599, 1609, 1619, 1629, 1638,
  126.      1648, 1658, 1668, 1678, 1687, 1697, 1707, 1717,
  127. 1696, 1704, 1713, 1722, 1730, 1739, 1747, 1756,
  128.      1764, 1773, 1781, 1790, 1798, 1807, 1815, 1824,
  129. 1727, 1737, 1747, 1756, 1766, 1776, 1786, 1795,
  130.      1805, 1815, 1825, 1835, 1844, 1854, 1864, 1874,
  131. 1730, 1741, 1752, 1762, 1773, 1784, 1795, 1805,
  132.      1816, 1827, 1838, 1849, 1859, 1870, 1881, 1892,
  133. 1837, 1845, 1854, 1863, 1871, 1880, 1888, 1897,
  134.      1905, 1914, 1922, 1931, 1939, 1948, 1956, 1965,
  135. 1884, 1894, 1904, 1913, 1923, 1933, 1943, 1952,
  136.      1962, 1972, 1982, 1992, 2001, 2011, 2021, 2031,
  137. 1903, 1914, 1925, 1935, 1946, 1957, 1968, 1978,
  138.      1989, 2000, 2011, 2022, 2032, 2043, 2054, 2065,
  139. 1978, 1986, 1995, 2004, 2012, 2021, 2029, 2038,
  140.      2046, 2055, 2063, 2072, 2080, 2089, 2097, 2106,
  141. 2041, 2051, 2061, 2070, 2080, 2090, 2100, 2110,
  142.      2119, 2129, 2139, 2149, 2159, 2168, 2178, 2188,
  143. 2076, 2087, 2098, 2108, 2119, 2130, 2141, 2152,
  144.      2162, 2173, 2184, 2195, 2206, 2216, 2227, 2238,
  145. 2120, 2128, 2137, 2145, 2154, 2162, 2171, 2179,
  146.      2188, 2196, 2205, 2213, 2222, 2230, 2238, 2247,
  147. 2198, 2208, 2218, 2227, 2237, 2247, 2257, 2267,
  148.      2276, 2286, 2296, 2306, 2316, 2325, 2335, 2345,
  149. 2249, 2260, 2271, 2281, 2292, 2303, 2314, 2325,
  150.      2335, 2346, 2357, 2368, 2379, 2389, 2400, 2411,
  151. 2355, 2365, 2375, 2384, 2394, 2404, 2414, 2424,
  152.      2433, 2443, 2453, 2463, 2473, 2482, 2492, 2502,
  153. 2422, 2433, 2444, 2454, 2465, 2476, 2487, 2498,
  154.      2508, 2519, 2530, 2541, 2552, 2562, 2573, 2584,
  155. 2595, 2606, 2617, 2627, 2638, 2649, 2660, 2671,
  156.      2681, 2692, 2703, 2714, 2725, 2735, 2746, 2757
  157. };
  158.  
  159. /*
  160.  * dxtxdin
  161.  *
  162.  * Take info from 'data' and stuff values in the P array, by using
  163.  * the setval (and setopval) functions.  'data' is the Yamaha VMEM format.
  164.  * This function works for both the dx100 and tx81z.
  165.  */
  166.  
  167. dxtxdin(data)
  168. char *data;
  169. {
  170.     int dop, adop, n, crs, fin, v;
  171.  
  172.     setdxtx();
  173.     if ( Tx81 )
  174.         txinit();
  175.     for ( n=1; n<=4; n++ ) {
  176.         dop = Dopmap[n-1]*10;
  177.         adop = Dopmap[n-1]*2;
  178.         setopval(n,"attack",data[0+dop]);
  179.         setopval(n,"decay1",data[1+dop]);
  180.         setopval(n,"level1",data[4+dop]);
  181.         setopval(n,"decay2",data[2+dop]);
  182.         setopval(n,"release",data[3+dop]);
  183.         setopval(n,"keyscale",data[5+dop]);
  184.         setopval(n,"ampmod",(data[6+dop]>>6)&01);
  185.         setopval(n,"egbias",(data[6+dop]>>3)&07);
  186.         setopval(n,"velocity",data[6+dop]&07);
  187.         setopval(n,"outlevel",data[7+dop]);
  188.  
  189.         if ( Tx81 ) {
  190.             crs = data[8+dop];
  191.             fin = (data[74+adop]) & 017;
  192.             v = freqin(crs,fin);
  193.             setopval(n,"freq",v);
  194.         }
  195.         else
  196.             setopval(n,"freq",data[8+dop]);
  197.  
  198.         setopval(n,"keyrate",data[9+dop]>>3);
  199.         setopval(n,"detune",data[9+dop]&07);
  200.  
  201.         if ( Tx81 ) {
  202.             setopval(n,"egsft",(data[73+adop]>>4)&03);
  203.             setopval(n,"fix",(data[73+adop]>>3)&01);
  204.             setopval(n,"wave",(data[74+adop]>>4)&07);
  205.         }
  206.     }
  207.     setval("lfosync",(data[40]>>6)&01);
  208.     setval("feedback",(data[40]>>3)&07);
  209.     setval("algorithm",data[40]&07);
  210.     setval("lfospeed",data[41]);
  211.     setval("lfodelay",data[42]);
  212.     setval("pmoddepth",data[43]);
  213.     setval("amoddepth",data[44]);
  214.     setval("pmodsens",(data[45]>>4)&07);
  215.     setval("amodsens",(data[45]>>2)&03);
  216.     setval("lfowave",data[45]&03);
  217.     setval("transpose",data[46]);
  218.     setval("pitchbend",data[47]);
  219.     setval("portatime",data[49]);
  220.     setval("modprange",data[51]);
  221.     setval("modarange",data[52]);
  222.     setval("breathprange",data[53]);
  223.     setval("breatharange",data[54]);
  224.     setval("breathpbias",data[55]);
  225.     setval("breathegbias",data[56]);
  226.     setval("playmode",(data[48]>>3)&01);
  227.     setval("susfoot",(data[48]>>2)&01);
  228.     setval("portfoot",(data[48]>>1)&01);
  229.     setval("portmode",data[48]&01);
  230.     setval("autochan",Channel);
  231.     if ( Tx81 ) {
  232.         setval("reverbrate",data[81]&07);
  233.         setval("fcpitch",data[82]);
  234.         setval("fcamp",data[83]);
  235.     }
  236. }
  237.  
  238. /*
  239.  * dxtxdout
  240.  *
  241.  * Take (possibly changed) parameters values out of the P array and
  242.  * put them back into 'data'.  'data' is in the Yamaha VMEM format.
  243.  * This works for both the dx100 and tx81z.
  244.  */
  245.  
  246. dxtxdout(data)
  247. char *data;
  248. {
  249.     int dop, n, crs, fin;
  250.  
  251.     for ( n=1; n<=4; n++ ) {
  252.         dop = Dopmap[n-1]*10;
  253.         data[0+dop] = getopval(n,"attack");
  254.         data[1+dop] = getopval(n,"decay1");
  255.         data[4+dop] = getopval(n,"level1");
  256.         data[2+dop] = getopval(n,"decay2");
  257.         data[3+dop] = getopval(n,"release");
  258.         data[5+dop] = getopval(n,"keyscale");
  259.         data[6+dop] = getopval(n,"ampmod")<<6
  260.                 | getopval(n,"egbias")<<3
  261.                 | getopval(n,"velocity");
  262.         data[7+dop] = getopval(n,"outlevel");
  263.         data[9+dop] = getopval(n,"keyrate")<<3 | getopval(n,"detune");
  264.  
  265.         if ( ! Tx81 ) {
  266.             data[8+dop] = getopval(n,"freq");
  267.         }
  268.         else {
  269.             freqout(getopval(n,"freq"),&crs,&fin);
  270.             data[8+dop] = crs;
  271.  
  272.             dop = Dopmap[n-1]*2;
  273.             data[73+dop] = getopval(n,"egsft")<<4
  274.                     | getopval(n,"fix")<<3
  275.                     /* | getopval(n,"fixrg") */;
  276.             data[74+dop] = getopval(n,"wave")<<4 | fin;
  277.         }
  278.     }
  279.     data[40] = getval("lfosync")<<6
  280.         | getval("feedback")<<3
  281.         | getval("algorithm");
  282.     data[41] = getval("lfospeed");
  283.     data[42] = getval("lfodelay");
  284.     data[43] = getval("pmoddepth");
  285.     data[44] = getval("amoddepth");
  286.     data[45] = getval("pmodsens")<<4 | getval("amodsens")<<2
  287.         | getval("lfowave");
  288.     data[46] = getval("transpose");
  289.     data[47] = getval("pitchbend");
  290.     data[49] = getval("portatime");
  291.     data[51] = getval("modprange");
  292.     data[52] = getval("modarange");
  293.     data[53] = getval("breathprange");
  294.     data[54] = getval("breatharange");
  295.     data[55] = getval("breathpbias");
  296.     data[56] = getval("breathegbias");
  297.     data[48] = (unsigned) ( getval("playmode")<<3
  298.         | getval("susfoot")<<2
  299.         | getval("portfoot")<<1
  300.         | getval("portmode"));
  301.  
  302.     if ( Tx81 ) {
  303.         data[81] = getval("reverbrate");
  304.         data[82] = getval("fcpitch");
  305.         data[83] = getval("fcamp");
  306.     }
  307.  
  308.     Channel = getval("autochan");
  309. }
  310.  
  311. setdxtx()
  312. {
  313.     if ( strcmp(Synthname,"DX-100")==0 )
  314.         Tx81 = 0;
  315.     else
  316.         Tx81 = 1;
  317. }
  318.  
  319. setopval(n,str,v)
  320. char *str;
  321. {
  322.     char buff[32];
  323.     sprintf(buff,"op%d%s",n,str);
  324.     setval(buff,v);
  325. }
  326.  
  327. getopval(n,str)
  328. char *str;
  329. {
  330.     char buff[32];
  331.     sprintf(buff,"op%d%s",n,str);
  332.     return(getval(buff));
  333. }
  334.  
  335. /*
  336.  * The routines below are used (in the P array) for printing the
  337.  * values of various parameters (e.g. the vism3num routine prints
  338.  * the value-3, which is appropriate for the 'detune' parameter.
  339.  */
  340.  
  341. char Numbuff[8];
  342.  
  343. char *visnum();
  344.  
  345. char *
  346. vis1num(v)
  347. {
  348.     sprintf(Numbuff,"%d",v+1);
  349.     return(Numbuff);
  350. }
  351.  
  352. char *
  353. vism3num(v)
  354. {
  355.     sprintf(Numbuff,"%d",v-3);
  356.     return(Numbuff);
  357. }
  358.  
  359. char *visonoff();
  360.  
  361. char *
  362. vismono(v)
  363. {
  364.     if ( v==0 )
  365.         return("poly");
  366.     else
  367.         return("mono");
  368. }
  369.  
  370. /*
  371.             4    2  4    2         4                             4
  372.             |    |  |    |         |               4             |
  373.         2---3    ---3    3  4   2  3   1  4     ___|___    1  2  3
  374.         |           |    |  |   |  |   |  |     |  |  |    |__|__|
  375.         1           1    1---   1---   2  3     1  2  3
  376.                                        |__|     |__|__|
  377.                                                              1  2  3  4
  378.                                                              |__|__|__|
  379.  */
  380.  
  381. char *Algostr[] = {
  382.     "1     ~d2---3~u~l|~u~l4~d~d~d~l~l~l~l~l|~l~d1",
  383.     "2     ~d---3~l~l~l~l~u|  |~l~l~l~l~u2  4~l~d~d~d|~l~d1",
  384.     "3     ~d3  4~l~l~l~l~u|~l~u2~l~d~d~d|  |~d~l~l~l~l1---",
  385.     "4     ~d2  3~l~u|~u~l4~l~d~d~d~l~l~l|  |~l~l~l~l~d1---",
  386.     "5     ~d~u1  4~d~l~l~l~l|  |~d~l~l~l~l2  3~d~l~l~l~l----",
  387.     "6     ~d|  |  |~u~l~l~l~l~l~l~l___|___~u~l~l~l~l4~l~d~d~d~l~l~l1  2  3~d~l~l~l~l~l~l~l|__|__|",
  388.     "7     ~d1  2  3~u~l|~u~l4~l~d~d~d~l~l~l~l~l~l|__|__|",
  389.     "8     ~d1  2  3  4~d~l~l~l~l~l~l~l~l~l~l|__|__|__|"
  390. };
  391.  
  392. char *
  393. visdx1a(v)
  394. {
  395.     if ( v >= 0 && v <= 7 )
  396.         return(Algostr[v]);
  397.     else
  398.         return("????");
  399. }
  400.  
  401. char *
  402. viswave(v)
  403. {
  404.     switch(v){
  405.     case 0: return("saw up");
  406.     case 1: return("square");
  407.     case 2: return("triangle");
  408.     case 3: return("s/hold");
  409.     default: return("???");
  410.     }
  411. }
  412.  
  413. char *Freqstr[] = {    /* values from 0 to 63 */
  414.     "0.50 ", "0.71 ", "0.78 ", "0.87 ", "1.00 ",
  415.     "1.41 ", "1.57 ", "1.73 ", "2.00 ", "2.82 ",
  416.     "3.00 ", "3.14 ", "3.46 ", "4.00 ", "4.24 ",
  417.     "4.71 ", "5.00 ", "5.19 ", "5.65 ", "6.00 ",
  418.     "6.28 ", "6.92 ", "7.00 ", "7.07 ", "7.85 ",
  419.     "8.00 ", "8.48 ", "8.65 ", "9.00 ", "9.42 ",
  420.     "9.89 ", "10.00", "10.38", "10.99", "11.00",
  421.     "11.30", "12.00", "12.11", "12.56", "12.72",
  422.     "13.00", "13.84", "14.00", "14.10", "14.13",
  423.     "15.00", "15.55", "15.57", "15.70", "16.96",
  424.     "17.27", "17.30", "18.37", "18.84", "19.03",
  425.     "19.78", "20.41", "20.76", "21.20", "21.98",
  426.     "22.49", "23.55", "24.22", "25.95"
  427. };
  428.  
  429. char *
  430. visfreq(v)
  431. {
  432.     if ( v >=0 && v <= 63 )
  433.         return ( Freqstr[v] );
  434.     else
  435.         return("????");
  436. }
  437.  
  438. /*
  439.  * dx1sedit
  440.  *
  441.  * Send a single voice to the edit buffer of the DX.
  442.  */
  443. dx1sedit(data)
  444. char *data;
  445. {
  446.     setdxtx();
  447.     if ( Tx81 )
  448.         sendaced(data);
  449.     sendvced(data);
  450. }
  451.  
  452. sendvced(data)
  453. char *data;
  454. {
  455.     char vdata[DX100VSIZE];
  456.     int n, cksum, c;
  457.  
  458.     clrdata(vdata,DX100VSIZE);
  459.     vmemtovced(data,vdata);
  460.     sendmidi(0xf0);
  461.     sendmidi(0x43);
  462.     sendmidi(Channel-1);    /* channel # */
  463.     sendmidi(0x03);        /* format type */
  464.     sendmidi(0x00);        /* byte count */
  465.     sendmidi(0x5d);        /* byte count */
  466.     cksum = 0;
  467.     for ( n=0; n<93; n++ ) {
  468.         sendmidi(c = (int)(vdata[n]));
  469.         cksum += c;
  470.     }
  471.     sendmidi((-cksum) & 0x7f);
  472.     sendmidi(EOX);
  473. }
  474.  
  475. sendaced(data)
  476. char *data;
  477. {
  478.     char *p, vdata[DX100VSIZE];
  479.     int n, cksum, c;
  480.  
  481.     clrdata(vdata,DX100VSIZE);
  482.     vmemtoaced(data,vdata);
  483.     sendmidi(0xf0);
  484.     sendmidi(0x43);
  485.     sendmidi(Channel-1);    /* channel # */
  486.     sendmidi(0x7e);        /* format type */
  487.     sendmidi(0x00);        /* byte count */
  488.     sendmidi(0x21);        /* byte count */
  489.     p = "LM  8976AE";
  490.     cksum = 0;
  491.     while ( (c=(int)(*p++)) != '\0' ) {
  492.         sendmidi(c);
  493.         cksum += c;
  494.     }
  495.     for ( n=0; n<23; n++ ) {
  496.         sendmidi(c=(int)(vdata[n]));
  497.         cksum += c;
  498.     }
  499.     sendmidi((-cksum) & 0x7f);
  500.     sendmidi(EOX);
  501. }
  502.  
  503. /*
  504.  * vmemtovced
  505.  *
  506.  * convert a vmem format voice to vced format.
  507.  */
  508.  
  509. vmemtovced(data,vdata)
  510. char *data;
  511. char *vdata;
  512. {
  513.     int vop, dop, n;
  514.  
  515.     for ( n=0; n<4; n++ ) {
  516.         /* vop = Dopmap[n]*13; */
  517.         vop = Dopmap[n]*13;
  518.         dop = Dopmap[n]*10;
  519.         vdata[vop+0] = data[dop+0];    /* attack rate */
  520.         vdata[vop+1] = data[dop+1];    /* decay 1 rate */
  521.         vdata[vop+2] = data[dop+2];    /* decay 2 rate */
  522.         vdata[vop+3] = data[dop+3];    /* release rate */
  523.         vdata[vop+4] = data[dop+4];    /* decal 1 level */
  524.         vdata[vop+5] = data[dop+5];    /* keyboard scaling level */
  525.         vdata[vop+6] = (data[dop+9]>>3);/* keyboard scaling rate */
  526.         vdata[vop+7] = (data[dop+6]>>3)&7;    /* eg bias sens. */
  527.         vdata[vop+8] = (data[dop+6]>>6)&1;    /* amp. mod. enable */
  528.         vdata[vop+9] = (data[dop+6]&7);    /* key velocity */
  529.         vdata[vop+10] = data[dop+7];    /* output level */
  530.         vdata[vop+11] = data[dop+8];    /* osc. frequency */
  531.         vdata[vop+12] = (data[dop+9]&7);    /* detune */
  532.     }
  533.     vdata[52] = (data[40]&7);    /* algorithm */
  534.     vdata[53] = (data[40]>>3)&7;    /* feedback level */
  535.     vdata[54] = data[41];        /* lfo speed */
  536.     vdata[55] = data[42];        /* lfo delay */
  537.     vdata[56] = data[43];        /* pitch modulation depth */
  538.     vdata[57] = data[44];        /* amplitude modulation depth */
  539.     vdata[58] = (data[40]>>6)&1;    /* lfo sync */
  540.     vdata[59] = data[45]&3;        /* lfo wave */
  541.     vdata[60] = (data[45]>>4)&7;        /* pitch modulation sens. */
  542.     vdata[61] = (data[45]>>2)&3;        /* amp. modulation sens. */
  543.     vdata[62] = data[46];        /* transpose */
  544.     vdata[63] = (data[48]>>3)&1;    /* play mode (poly/mono) */
  545.     vdata[64] = data[47];        /* pitch bend range */
  546.     vdata[65] = (data[48]&1);    /* portamento mode */
  547.     vdata[66] = data[49];        /* portamento time */
  548.     vdata[67] = data[50];        /* foot volume range */
  549.     vdata[68] = (data[48]>>2)&1;    /* sustain foot switch */
  550.     vdata[69] = (data[48]>>1)&1;    /* portamento foot switch */
  551.     vdata[70] = (data[48]>>4)&1;    /* chorus switch */
  552.     vdata[71] = data[51];        /* mod. wheel pitch mod. range */
  553.     vdata[72] = data[52];        /* mod. wheel ampli. mod. range */
  554.     vdata[73] = data[53];        /* breath pitch mod. range */
  555.     vdata[74] = data[54];        /* breath ampli. mod. range */
  556.     vdata[75] = data[55];        /* breath control pitch bias range */
  557.     vdata[76] = data[56];        /* breath control EG bias range */
  558.     for ( n=77; n<93; n++ )        /* voice name AND pitch EG rates */
  559.         vdata[n] = data[n-20];
  560. }
  561.  
  562. /*
  563.  * vmemtoaced
  564.  *
  565.  * Convert a vmem format voice to aced format (TX81Z).
  566.  */
  567.  
  568. vmemtoaced(data,adata)
  569. char *data;
  570. char *adata;
  571. {
  572.     int vop, aop, n;
  573.  
  574.     for ( n=0; n<4; n++ ) {
  575.         vop = 73 + Dopmap[n]*2;
  576.         aop = Dopmap[n]*5;
  577.         adata[0+aop] = (data[vop]>>3) & 01;    /* fixed freq (0,1) */
  578.         adata[1+aop] = data[vop] & 07;       /* fixed freq range (0-7) */
  579.         adata[2+aop] = data[vop+1] & 017;       /* freq range fine (0-15) */
  580.         adata[3+aop] = (data[vop+1]>>4) & 07;  /* op. waveform (0-7) */
  581.         adata[4+aop] = (data[vop]>>3) & 03;   /* EG shift (0-3) */
  582.     }
  583.     adata[20] = data[81] & 07;    /* reverb rate */
  584.     adata[21] = data[82];    /* Foot controller pitch */
  585.     adata[22] = data[83];    /* Foot controller amp. */
  586. }
  587.  
  588. #ifdef OLD
  589. /*
  590.  * Send a single parameter value.
  591.  */
  592. sendparam(param,val)
  593. {
  594.     sendmidi(0xf0);
  595.     sendmidi(0x43);
  596.     sendmidi(0x10);    /* Channel? */
  597.     sendmidi(0x12);
  598.     sendmidi(param);
  599.     sendmidi(val);
  600.     sendmidi(EOX);
  601. }
  602.  
  603. /*
  604.  * remotely press a key on the DX
  605.  */
  606. presskey(key,val)
  607. {
  608.     sendmidi(0xf0);
  609.     sendmidi(0x43);
  610.     sendmidi(0x10);    /* Channel? */
  611.     sendmidi(0x08);
  612.     sendmidi(key);
  613.     sendmidi(val);
  614.     sendmidi(EOX);
  615. }
  616.  
  617. /*
  618.  * tovmem
  619.  *
  620.  * convert a vced format voice to vmem format.
  621.  */
  622.  
  623. tovmem(vdata,data)
  624. char *vdata;    /* vced format data */
  625. char *data;    /* vmem format */
  626. {
  627.     int vop, dop, n;
  628.  
  629.     for ( n=0; n<4; n++ ) {
  630.         vop = Dopmap[n]*13;
  631.         dop = Dopmap[n]*10;
  632.         data[dop+0] = vdata[vop+0];    /* attack rate */
  633.         data[dop+1] = vdata[vop+1];    /* decay 1 rate */
  634.         data[dop+2] = vdata[vop+2];    /* decay 2 rate */
  635.         data[dop+3] = vdata[vop+3];    /* release rate */
  636.         data[dop+4] = vdata[vop+4];    /* decal 1 level */
  637.         data[dop+5] = vdata[vop+5];    /* keyboard scaling level */
  638.                 /* amp. mod. enab/eg bias sens/key velocity */
  639.         data[dop+6]=(vdata[vop+8]<<6) | (vdata[vop+7]<<3) | vdata[vop+9];
  640.         data[dop+7] = vdata[vop+10];    /* output level */
  641.         data[dop+8] = vdata[vop+11];    /* osc. frequency */
  642.                 /* key scaling rate/detune */
  643.         data[dop+9] = (vdata[vop+6]<<3) | vdata[vop+12];
  644.     }
  645.         /* lfo sync/feedback level/algorithm */
  646.     data[40] = (vdata[58]<<6) | (vdata[53]<<3) | vdata[52];
  647.     data[41] = vdata[54];        /* lfo speed */
  648.     data[42] = vdata[55];        /* lfo delay */
  649.     data[43] = vdata[56];        /* pitch modulation depth */
  650.     data[44] = vdata[57];        /* amplitude modulation depth */
  651.         /* pitch mod. sens/amp. mod. sens/lfo wave */
  652.     data[45] = (vdata[60]<<4) | (vdata[61]<<2) | vdata[59];
  653.     data[46] = vdata[62];        /* transpose */
  654.  
  655.         /* chorus/playmode/sustain/portamento-foot/portamento-mode */
  656.     data[48] = (vdata[70]<<4)|(vdata[63]<<3)|(vdata[68]<<2)|(vdata[69]<<1)
  657.         | vdata[65];
  658.  
  659.     data[47] = vdata[64];        /* pitch bend range */
  660.     data[49] = vdata[66];        /* portamento time */
  661.     data[50] = vdata[67];        /* foot volume range */
  662.     data[51] = vdata[71];        /* mod. wheel pitch mod. range */
  663.     data[52] = vdata[72];        /* mod. wheel ampli. mod. range */
  664.     data[53] = vdata[73];        /* breath pitch mod. range */
  665.     data[54] = vdata[74];        /* breath ampli. mod. range */
  666.     data[55] = vdata[75];        /* breath control pitch bias range */
  667.     data[56] = vdata[76];        /* breath control EG bias range */
  668.     for ( n=77; n<93; n++ )        /* voice name AND pitch EG rates */
  669.         data[n-20] = vdata[n];
  670. }
  671. #endif
  672.  
  673. /* dx1nof - return a pointer to the voice name buried in data */
  674. char *
  675. dx1nof(data)
  676. char *data;
  677. {
  678.     static char currbuff[DX100NSIZE+1];
  679.     char *p;
  680.     int m;
  681.  
  682.     p = currbuff;
  683.     for ( m=0; m<10; m++ )
  684.         *p++ = data[57+m];
  685.     *p = '\0';
  686.     return(currbuff);
  687. }
  688.  
  689. /* dx1snof - set the voice name buried in data to name */
  690. dx1snof(data,name)
  691. char *data;
  692. char *name;
  693. {
  694.     char *p;
  695.     int m;
  696.  
  697.     for ( p=name,m=0; *p!='\0' && m<10; p++,m++ )
  698.         data[57+m] = *p;
  699.     for ( ; m<10; m++ )
  700.         data[57+m] = ' ';
  701. }
  702.  
  703. /* dx1sbulk - send a bulk dump to the DX-100 */
  704. dx1sbulk(data)
  705. char *data;
  706. {
  707.     int c, v, n, cksum;
  708.  
  709.     sendmidi(0xf0);
  710.     sendmidi(0x43);
  711.     sendmidi(Channel-1);    /* Channel # */
  712.     sendmidi(0x04);
  713.     sendmidi(0x20);
  714.     sendmidi(0x00);
  715.     cksum = 0;
  716.     /* send 32 voices worth of data */
  717.     for ( v=0; v<32; v++ ) {
  718.         for ( n=0; n<DX100VSIZE; n++ ) {
  719.             /* The DX100 can only handle 24 voices (but needs */
  720.             /* to have 32 voices worth of data sent, anyway) */
  721.             if ( v >= 24 && ( ! Tx81 ) )
  722.                 c = 0;
  723.             else
  724.                 c = VOICEBYTE(data,v,n);
  725.             sendmidi(c & 0xff);
  726.             cksum += c;
  727.         }
  728.     }
  729.     sendmidi((-cksum) & 0x7f);
  730.     sendmidi(0xf7);
  731. }
  732.  
  733. /* dx1gbulk - Request and read a bulk dump from the DX-100 */
  734. dx1gbulk(data)
  735. char *data;
  736. {
  737.     int c, n, v, b1, b2, cksum, ret = 1;
  738.     long begin, toolong;
  739.  
  740.     setdxtx();
  741.     flushmidi();
  742.  
  743.     sendmidi(0xf0);
  744.     sendmidi(0x43);
  745.     sendmidi(0x20 | (Channel-1) );    /* Channel # */
  746.     sendmidi(4);            /* 4 == 32 voice bulk dump */
  747.     sendmidi(EOX);            /* EOX */
  748.  
  749.     begin = milliclock();
  750.     toolong = begin + 1000 * TIMEOUT;
  751.  
  752.     /* wait for the x43 byte starting the dump */
  753.     while ( milliclock() < toolong ) {
  754.         if ( STATMIDI && (c=(getmidi() & 0xff)) == 0x43 )
  755.             break;
  756.     }
  757.     if ( c != 0x43 ) {
  758.         Reason = "Timeout waiting for 0x43";
  759.         goto getout;
  760.     }
  761.     getmidi();    /* channel # */
  762.     getmidi();    /* format # */
  763.     getmidi();    /* byte count high byte */
  764.     getmidi();    /* byte count low byte */
  765.  
  766.     cksum = 0;
  767.     /* 32 voices are dumped */
  768.     for ( v=0; v<32; v++ ) {
  769.         for ( n=0; n<DX100VSIZE; n++ ) {
  770.             /* twiddle your thumbs, but not forever */
  771.             while ( ! STATMIDI ) {
  772.                 if ( milliclock() > toolong )
  773.                     goto timeout;    /* the end of an era */
  774.             }
  775.             c = (getmidi() & 0xff);
  776.             /* Ignore non-data bytes ? */
  777.             if ( c & 0x80 )
  778.                 continue;
  779.             /* compute checksum */
  780.             cksum += c;
  781.             /* Only 24 voices are used on the DX100 */
  782.             if ( v < 24 || Tx81 )
  783.                 VOICEBYTE(data,v,n) = c;
  784.         }
  785.     }
  786. timeout:
  787.     if ( v < 32 ) {
  788.         Reason = "Timeout while reading!";
  789.         goto getout;
  790.     }
  791.     b1 = (getmidi() & 0xff);    /* Checksum */
  792.     b2 = (getmidi() & 0xff);    /* EOX */
  793.     cksum = (-cksum) & 0x7f;    /* convert to what we must match */
  794.     if ( b2 != EOX )
  795.         Reason = "EOX not received";
  796.     else if ( b1 != cksum ) {
  797.         static char ckbuff[80];
  798.         sprintf(ckbuff,"Checksum doesn't match (got %d expected %d)",b1,cksum);
  799.         /* Reason = "Checksum doesn't match"; */
  800.         Reason = ckbuff;
  801.     }
  802.     else {
  803.         Reason = "";
  804.         ret = 0;    /* all's well */
  805.     }
  806. getout:
  807.     return(ret);
  808. }
  809.  
  810. #ifdef OLDSTUFF
  811. dxchecksum(data)
  812. char *data;
  813. {
  814.     int v, n, s=0;
  815.  
  816.     for ( v=0; v<DX100NVOICES; v++ ) {
  817.         for ( n=0; n<DX100VSIZE; n++ ) {
  818.             s += (int)(VOICEBYTE(data,v,n));
  819.             while ( s > 128 )
  820.                 s -= 128;
  821.         }
  822.     }
  823.     return(128-s);
  824. }
  825. #endif
  826.  
  827. freqin(crs,fin)
  828. {
  829.     int n, f;
  830.  
  831.     txinit();
  832.     f = txfreq[crs*16+fin];
  833.     for ( n=0; n<txleng; n++ ) {
  834.         if ( txfreq[txindex[n]] == f )
  835.             return(n);
  836.     }
  837.     return(0);
  838. }
  839.  
  840. freqout(v,acrs,afin)
  841. int *acrs;
  842. int *afin;
  843. {
  844.     int i;
  845.  
  846.     i = txindex[v];
  847.     *acrs = i/16;
  848.     *afin = i%16;
  849. }
  850.  
  851. txinit()
  852. {
  853.     int n, k;
  854.     char *parm;
  855.  
  856.     if ( txindex != NULL )
  857.         return;
  858.     /* create an array of indexes into txfreq, giving a sorted */
  859.     /* list of unique frequencies. */
  860.     txindex = (int *) alloc(sizeof(int) * 64 * 16);
  861.     for ( n=0; n<64; n++ ) {
  862.         for ( k=0; k<16; k++ ) {
  863.             int freq = txfreq[n*16+k];
  864.             register int i, f;
  865.             register int *p, *endp;
  866.  
  867.             /* insertion sort, starting from top of already */
  868.             /* sorted list, since the values we're inserting */
  869.             /* are almost sorted already. */
  870.             for ( i=txleng-1; i>=0; i-- ) {
  871.                 if ( (f=txfreq[txindex[i]]) < freq )
  872.                     break;
  873.                 if ( f == freq )
  874.                     goto dontadd;
  875.             }
  876.             i++;
  877.             /* shift everything up one */
  878.             p = &txindex[txleng];
  879.             endp = &txindex[i];
  880.             for ( ; p>endp; p-- )
  881.                 *p = *(p-1);
  882.             txindex[i] = 16*n+k;
  883.             txleng++;
  884.             dontadd: ;
  885.         }
  886.     }
  887.     /* set the maximum value for the frequency parameters */
  888.     parm = "op#freq";
  889.     for ( n=1; n<=4; n++ ) {
  890.         parm[2] = '0' + n;
  891.         if ( (k=parmindex(parm)) >= 0 )
  892.             P[k].p_max = txleng-1;
  893.     }
  894. }
  895.